1. Field of the Invention
This invention pertains to the arts of computer network, Internet and intranet web server technology, and especially to the arts of providing dynamic and variable web page content from a web server.
2. Description of the Related Art
The Internet and the World Wide Web have become critical, integral parts of commercial operations, personal lives, and the education process. Development activities of content for the World Wide Web is at an all-time high level, with expectations of tremendous growth to come. This is driven by even greater increases in the number of people and systems which are connected to the Internet and are exploiting its capabilities.
At the heart of the Internet content is Internet browser technology and Internet server technology. An Internet server contains content which is available to systems and browsers which have Internet connectivity. The most common type of Internet content is Hyper Text Markup Language documents.
Hyper Text Markup Language (“HTML”) documents provide the content building blocks for designing World Wide Web pages. The HTML standard can trace its roots as far back as the 1960's. The Internet (interconnected network) was established in the early 1960's as nothing more than an interconnection of computers on a worldwide basis. By the mid-1970's, many research labs, universities and government agencies were on the network, and it was at that time known as ARPAnet.
A major problem that existed, however, was the lack of a standard protocol for communication. Each of the various groups was using its own protocol to run its internal network.
In 1982, a network protocol was implemented based on a paper entitled, “A Protocol for Packet Network Internetworking”, published in 1974 by Cerf and Kahn. The paper set forth a method for transferring data between computers which were interconnected via the Internet, which became known as the Transmission Control Protocol/Internet Protocol (“TCP/IP”). This standard was quickly adopted around the world for Internet communications, and remains so today.
In 1991, an application called “Gopher” was created at the University of Minnesota. Gopher provided a useful method of presenting menus and organizing files on the Internet. The World Wide Web (“WWW”) expanded upon the Gopher approach. Originally created by the European High-Energy Particle Physics Lab (CERN), the WWW added many improvements including graphics and, most importantly, hypertext links.
Under the CERN WWW definition, hypertext is a method of adding links to particular words, phrases, or graphics in a document such that when a user selects the element in the document, the user is automatically provided with a connection to another document or web server. To achieve this, the WWW implemented three technologies:                (a) HTML which was used to design and present web pages,        (b) the Hyper Text Transfer Protocol for transmitting these web pages over the WWW, and        (c) the conceptual definition of a web browser, which is a WWW client computer application that interprets and displays web pages received from a source such as a web server.        
Using the WWW, HTTP and a web browser, users can easily create documents that are displayed to other users which visually look like pages in a book rather than a traditional computer screen appearance.
In 1993, the National Center for Supercomputing Applications (NCSA) at the University of Illinois at Champaign-Urbana developed and released a very powerful browser called “Mosaic”. Due to it's being offered free of charge, it is estimated that over 2 million users had begun to use it to browse documents on the WWW by 1995. In the years following, Netscape Communications Corporation released its Navigator browser, and then Microsoft Corporation released its Explorer browser, both of which were compatible with HTML and HTTP.
HTML is analogous to the editor's marks on a written document. The “marks” of the markup language specify to the web browser how the information should be displayed to the user. For example, if one wants text to be displayed in bold, all that needs to be done is to “mark” the text to be displayed in bold. This is accomplished by surrounding the text with control characters, or “tags”, which are bracketed by “< >” in the text. An HTML document is a text file containing information to be displayed, control characters, hyperlinks, and sometimes executable code. For example, a bold line of text in an HTML file would look like:                <b> This text is now bold </b>        
The <b> tag turns on the bold attribute and the </b> tag turns off the bold attribute. Normally, the control characters are not displayed to the user by the browser software. Other control characters can set the color and size of text, define the use of a background color or graphics pattern or file, define the size and shape of tables, define drop down choice lists, locate and set the size for the insertion and display of graphics data, create radio buttons, and show hyperlinks as graphics or specially marked text. HTML is well known within the art.
HTML provides an elegant way to easily create pages that can contain complicated links to other documents through the use of hypertext links. Although HTML gained rapid acceptance, soon users wanted much more graphical power and content control capabilities.
FIG. 1 shows the fundamental client-server arrangement of Internet and intranet communications. A client browser computer (1) is provided with Internet access (2) to the World Wide Web (3) through common means such as a dial-up telephone line and modem, cable modem, or local area network (“LAN”). A web server computer (5) is likewise provided with Internet access (4) to the World Wide Web (3) using similar means, or higher-bandwidth means such as T1 and T3 data lines. Alternatively, client and servers may be interconnected via an Intranet (6), such as a corporate LAN. These arrangements are well known within the art.
FIG. 2 shows the prior art process of fetching and displaying static HTML pages from a web server over an Internet (3) or Intranet (6). When the user selects (10) a Universal Resource Locator (“URL”) or hyperlink to view on his or her browser computer (1), the browser creates an HTTP request to fetch the file requested. The browser then transmits an HTTP GET command (11) via the World Wide Web (3) to the web server computer (5). The web server receives the command (12), and retrieves the requested static HTML file from its memory. Finally, the web server (5) transmits (13) the HTML file using the HTTP protocol to the client browser computer (14), where it is received (15), interpreted and displayed to the user.
The general limitation with basic HTML is that it is generally static in content. After a developer has designed an HTML page, the page is essentially fixed in its content, layout and appearance. Each time a user loads that page, it will look essentially the same as the day it was created by the developer.
A number of technologies have been developed to extend the capabilities of HTML to allow for some levels of dynamic, or changing, content of HTML pages, including:                (a) HTML extensions, such as “server-side includes”,        (b) Common Gateway Interface (“CGI”), and        (c) Client-side scripting.        
A “server-side include” is a method of handling changing information provided that information resides on the same server as the base HTML page. A special tag is added in the HTML code for the base page that specifies the additional HTML file to be included. When the web server receives an HTTP request for a document, the web server first opens the requested document and searches to see if any additional files need to be included. If so, the server includes the file(s) and then sends the newly built document to the browser. An example “server-side include” is given in Table 1.
TABLE 1Example Server-Side IncludeContents of the base HTML file:<HTML><HEAD><TITLE>Example of a server-side include</TITLE></HEAD><BODY><!-- #INCLUDE FILE=“MyInc.html”--><P>I can put other information here</P></BODY></HTML>Contents of the “included”file MyInc.html:<H1>Some simple text to include</H1>
FIG. 3 shows the basic steps involved for the “browsing” of HTML pages which implement “server-side includes”. The process is very similar to the process to fetch static HTML pages as shown in FIG. 2 and described supra, with the exception that when the web server (5) receives the HTTP GET command, it retrieves (20) the HTML file, parses it for the server-side includes, fetches the data indicated by the server-side includes, replaces the HTML of the server-side includes with the data, and transmits (14) the whole HTML file (with included data) to the client browser computer (1).
Although “server-side includes” provide a basic method of incorporating information that changes periodically, they place a processing burden on the server since the server has to parse the entire document every time the document is requested. An additional problem is that available options on different web server platforms vary depending on the specific type of server being used.
Common Gateway Interface (“CGI”), is another well-known method for providing user interactivity. CGI is more sophisticated than “server-side includes”. CGI scripting is a method that links the web server to other software applications, not just files, that can be executed on the server. CGI relies upon an additional layer to the HTTP transaction protocol which allows additional information to be passed from the browser to the server. This additional information is often information users fill out in forms that they submit, but it is not limited just to forms. When the server receives the information, it is passed to the CGI application and then sends the output of the application back to the browser. The output of the CGI application is a newly built HTML document.
Table 2 contains an example PERL application which could be executed by a web server in conjunction a CGI call from an HTML page when the page has been accessed by a browser.
TABLE 2Example PERL Applicationprint “Content-type: text/html\n\n”;print “<HTML>\n”;print “<HEAD><TITLE>This is a CGI Example</TITLE></HEAD>”;print “<BODY>\n”;print “<H1>Display this text on the page on the browser.</H1>\n”;print “</BODY>\n”;print “</HTML>\n;
When executed, the application of Table 2 would return the proper HTML code to display the text “Display this text on the page on the browser”. Although this method is a more powerful way of allowing HTML code to be created dynamically based on information provided by the user, and it also provides a way to store user input on the server, this method also can require significant web server processing bandwidth, and may have varying feature support from one server platform to another.
The third well-known technology which allows for some level of dynamic content of HTML pages is “client-side scripting”. Client-side scripting allows for client-executable code to be included in the HTML page, and to be executed on the browser/client platform after the HTML page is downloaded from the web server. Since the client platform is executing the script, the web server bandwidth problem of “server-side includes” and CGI scripting are avoided. The HTML version 4.0 standard supports client-side scripting using <SCRIPT> and <NOSCRIPT> tags.
And although just about any language could be used to implement the scripts, the most common in use today are JavaScript, JScript, VBScript and ECMAScript. The browser platform must support the particular script language, or it will not be executed correctly.
Using a client-side scripting language, the developer can insert instructions directly into the HTML code so that the script can be executed by the client platform when the page is loaded from the web server. The result of executing the script is that the script may generate some HTML code that tells the browser how to display information. By using other features such as Cascading Style Sheets and Document Object Models, client-side script processes can directly modify properties and attributes of document objects thereby causing the browser to modify the way the information is displayed.
Table 3 contains an example using JavaScript to display the current date on the web page.
TABLE 3Example Client-Side Script in JavaScript<HTML><HEAD><TITLE>Example of a client-side script in JavaScript</TITLE></HEAD><BODY><SCRIPT LANGUAGE=“JavaScript”><! -Hide this code from non JavaScript enabledbrowsersdocument.writeln(“<H1>Today is </P>”);var today = new Date( );var text= “The current date is” + (today.getMonth( ) + 1) + “/” +today.getDate( ) + “/” +today.getYear( ) + “.”;document.writeln(text);//--></SCRIPT></BODY></HTML>
The client-side script of Table 3 does nothing inbrowsers which do not support JavaScript, but will retrieve the system month, day, and year and print it on the browser screen prefaced by “The current date is”.
Because this script is processed by the client computer platform, not the web server, the client platform must process the HTML document to find any scripts that need to be compiled and/or executed. When the document is loading, the script may actively create HTML code. The primary problem with client-side scripting is the compatibility issue, where many client browser software packages currently installed do not support the client-side scripting.
Therefore, there is a need in the art for a server-side technology which provides the ability to map dynamic data into an existing HTML document or HTML template. Further, there is a need in the art for this server-side technology to be platform independent, and to be indifferent to various hardware and software functionalities which may or may not be resident on a web server.
Finally, there is a need in the art for this server-side technology to be suitable for real-time processing of dynamic data into HTML templates without a burdensome processor bandwidth requirement of the web server processor.